home *** CD-ROM | disk | FTP | other *** search
/ Freaks Macintosh Archive / Freaks Macintosh Archive.bin / Freaks Macintosh Archives / Hacking & Misc / bundle of exploits.sit / bundle of exploits / rootkits / rootkit / route.c < prev    next >
Text File  |  1994-03-01  |  9KB  |  382 lines
  1. /*
  2.  * Copyright (c) 1983 Regents of the University of California.
  3.  * All rights reserved.  The Berkeley software License Agreement
  4.  * specifies the terms and conditions for redistribution.
  5.  */
  6.  
  7. #ifndef lint
  8. static    char sccsid[] = "@(#)route.c 1.1 91/11/13 SMI"; /* from UCB 5.6 86/04/23 */
  9. #endif
  10.  
  11. #include <sys/param.h>
  12. #include <sys/socket.h>
  13. #include <sys/mbuf.h>
  14.  
  15. #include <net/if.h>
  16. #include <net/route.h>
  17. #include <netinet/in.h>
  18.  
  19. #ifdef    ENABLE_XNS
  20. #include <netns/ns.h>
  21. #endif    ENABLE_XNS
  22.  
  23. #include <netdb.h>
  24.  
  25. extern    int kread();
  26. extern    int nflag;
  27. extern    char *routename(), *netname(), *inet_ntoa();
  28. #ifdef    ENABLE_XNS
  29. extern    char *ns_print();
  30. #endif    ENABLE_XNS
  31.  
  32. /*
  33.  * Definitions for showing gateway flags.
  34.  */
  35. struct bits {
  36.     short    b_mask;
  37.     char    b_val;
  38. } bits[] = {
  39.     { RTF_UP,    'U' },
  40.     { RTF_GATEWAY,    'G' },
  41.     { RTF_HOST,    'H' },
  42.     { RTF_DYNAMIC,    'D' },
  43.     { 0 }
  44. };
  45.  
  46. /*
  47.  * Print routing tables.
  48.  */
  49. routepr(hostaddr, netaddr, hashsizeaddr)
  50.     off_t hostaddr, netaddr, hashsizeaddr;
  51. {
  52.     struct mbuf mb;
  53.     register struct rtentry *rt;
  54.     register struct mbuf *m;
  55.     register struct bits *p;
  56.     char name[16], *flags;
  57.     struct mbuf **routehash;
  58.     struct ifnet ifnet;
  59.     int hashsize;
  60.     int i, doinghost = 1;
  61.  
  62.     if (hostaddr == 0) {
  63.         printf("rthost: symbol not in namelist\n");
  64.         return;
  65.     }
  66.     if (netaddr == 0) {
  67.         printf("rtnet: symbol not in namelist\n");
  68.         return;
  69.     }
  70.     if (hashsizeaddr == 0) {
  71.         printf("rthashsize: symbol not in namelist\n");
  72.         return;
  73.     }
  74.     kread(hashsizeaddr, &hashsize, sizeof (hashsize));
  75.     routehash = (struct mbuf **)malloc( hashsize*sizeof (struct mbuf *) );
  76.     kread(hostaddr, routehash, hashsize*sizeof (struct mbuf *));
  77.     printf("Routing tables\n");
  78.     printf("%-20.20s %-20.20s %-8.8s %-6.6s %-10.10s %s\n",
  79.         "Destination", "Gateway",
  80.         "Flags", "Refcnt", "Use", "Interface");
  81. again:
  82.     for (i = 0; i < hashsize; i++) {
  83.         if (routehash[i] == 0)
  84.             continue;
  85.         m = routehash[i];
  86.         while (m) {
  87.             struct sockaddr_in *sin;
  88.  
  89.             kread(m, &mb, sizeof (mb));
  90.             rt = mtod(&mb, struct rtentry *);
  91.             if ((unsigned)rt < (unsigned)&mb ||
  92.                 (unsigned)rt >= (unsigned)(&mb + 1)) {
  93.                 printf("???\n");
  94.                 return;
  95.             }
  96.  
  97.             switch(rt->rt_dst.sa_family) {
  98.             case AF_INET:
  99.                 sin = (struct sockaddr_in *)&rt->rt_dst;
  100.                 printf("%-20.20s ",
  101.                     (sin->sin_addr.s_addr == 0) ? "default" :
  102.                     (rt->rt_flags & RTF_HOST) ?
  103.                     routename(sin->sin_addr) :
  104.                     netname(sin->sin_addr.s_addr, 0));
  105.                 sin = (struct sockaddr_in *)&rt->rt_gateway;
  106.                 printf("%-20.20s ", routename(sin->sin_addr));
  107.                 break;
  108. #ifdef    ENABLE_XNS
  109.             case AF_NS:
  110.                 printf("%-20s ",
  111.                     ns_print((struct sockaddr_ns *)&rt->rt_dst));
  112.                 printf("%-20s ",
  113.                     ns_print((struct sockaddr_ns *)&rt->rt_gateway));
  114.                 break;
  115. #endif    ENABLE_XNS
  116.             default: {
  117.                 u_short *s = (u_short *)rt->rt_dst.sa_data;
  118.  
  119.                 printf("(%d)%x %x %x %x %x %x %x ",
  120.                     rt->rt_dst.sa_family,
  121.                     s[0], s[1], s[2], s[3], s[4], s[5], s[6]);
  122.                 s = (u_short *)rt->rt_gateway.sa_data;
  123.                 printf("(%d)%x %x %x %x %x %x %x ",
  124.                     rt->rt_gateway.sa_family,
  125.                     s[0], s[1], s[2], s[3], s[4], s[5], s[6]);
  126.                 }
  127.             }
  128.             for (flags = name, p = bits; p->b_mask; p++)
  129.                 if (p->b_mask & rt->rt_flags)
  130.                     *flags++ = p->b_val;
  131.             *flags = '\0';
  132.             printf("%-8.8s %-6d %-10d ", name,
  133.                 rt->rt_refcnt, rt->rt_use);
  134.             if (rt->rt_ifp == 0) {
  135.                 putchar('\n');
  136.                 m = mb.m_next;
  137.                 continue;
  138.             }
  139.             kread(rt->rt_ifp, &ifnet, sizeof (ifnet));
  140.             kread((int)ifnet.if_name, name, 16);
  141.             printf("%s%d\n", name, ifnet.if_unit);
  142.             m = mb.m_next;
  143.         }
  144.     }
  145.     if (doinghost) {
  146.         kread(netaddr, routehash, hashsize*sizeof (struct mbuf *));
  147.         doinghost = 0;
  148.         goto again;
  149.     }
  150.     free(routehash);
  151. }
  152.  
  153. char *
  154. routename(in)
  155.     struct in_addr in;    /* in network order */
  156. {
  157.     register char *cp;
  158.     static char line[50];
  159.     struct hostent *hp;
  160.     static char domain[MAXHOSTNAMELEN + 1];
  161.     static int first = 1;
  162.     char *index();
  163.  
  164.     if (first) {
  165.         /*
  166.          * Record domain name for future reference.  Check
  167.          * first for the 4.3bsd convention of keeping it as
  168.          * part of the hostname.  Failing that, try extracting
  169.          * it using the domainname system call.
  170.          */
  171.         first = 0;
  172.         if (gethostname(domain, MAXHOSTNAMELEN) == 0 &&
  173.             (cp = index(domain, '.')))
  174.             (void) strcpy(domain, cp + 1);
  175.         else if (getdomainname(domain, MAXHOSTNAMELEN) < 0)
  176.             domain[0] = 0;
  177.     }
  178.     cp = 0;
  179.     if (!nflag) {
  180.         hp = gethostbyaddr(&in, sizeof (struct in_addr),
  181.             AF_INET);
  182.         if (hp) {
  183.             /*
  184.              * If the hostname contains a domain part,
  185.              * and it's the same as the local domain,
  186.              * elide it.
  187.              */
  188.             if ((cp = index(hp->h_name, '.')) &&
  189.                 !strcmp(cp + 1, domain))
  190.                 *cp = 0;
  191.             cp = hp->h_name;
  192.         }
  193.     }
  194.     if (cp)
  195.         strcpy(line, cp);
  196.     else
  197.         strcpy(line, inet_ntoa(in));
  198.     return (line);
  199. }
  200.  
  201. /*
  202.  * Return the name of the network whose address is given.
  203.  * The address is assumed to be that of a net or subnet, not a host.
  204.  */
  205. char *
  206. netname(iaddr, mask)
  207.     u_long iaddr;
  208.     u_long mask;
  209. {
  210.     char *cp = 0;
  211.     static char line[50];
  212.     struct in_addr in;
  213.  
  214.     in.s_addr = ntohl(iaddr);
  215.     if (!nflag && in.s_addr) {
  216.         struct netent *np = 0;
  217.         struct hostent *hp;
  218.         u_long net;
  219.  
  220.         if (mask == 0) {
  221.             register u_long i = in.s_addr;
  222.             int subnetshift;
  223.  
  224.             if (IN_CLASSA(i)) {
  225.                 mask = IN_CLASSA_NET;
  226.                 subnetshift = 8;
  227.             } else if (IN_CLASSB(i)) {
  228.                 mask = IN_CLASSB_NET;
  229.                 subnetshift = 8;
  230.             } else {
  231.                 mask = IN_CLASSC_NET;
  232.                 subnetshift = 4;
  233.             }
  234.             /*
  235.              * If there are more bits than the standard mask
  236.              * would suggest, subnets must be in use.
  237.              * Guess at the subnet mask, assuming reasonable
  238.              * width subnet fields.
  239.              */
  240.             while (in.s_addr &~ mask)
  241.                 mask = (long)mask >> subnetshift;
  242.         }
  243.         net = in.s_addr & mask;
  244.         /*
  245.          * Right-justify the network number.
  246.          *
  247.          * This is a throw-back to the old conventions used in the
  248.          * kernel.  We now store it left-justified in the kernel,
  249.          * but still right-justified in the NIS maps for backward
  250.          * compatibility.
  251.          */
  252.         while ((mask & 1) == 0)
  253.             mask >>= 1, net >>= 1;
  254.         np = getnetbyaddr(net, AF_INET);
  255.         if (np && np->n_net == net)
  256.             cp = np->n_name;
  257.         else {
  258.               /*
  259.                * gethostbyaddr takes network order; above
  260.                * wanted host order.
  261.                */
  262.             in.s_addr = iaddr;
  263.             hp = gethostbyaddr(&in,sizeof(struct in_addr),AF_INET);
  264.             if (hp)
  265.               cp = hp->h_name;
  266.         }
  267.     }
  268.     if (cp)
  269.         strcpy(line, cp);
  270.     else {
  271.         in.s_addr = iaddr;
  272.         strcpy(line, inet_ntoa(in));
  273.     }
  274.     return (line);
  275. }
  276.  
  277. /*
  278.  * Print routing statistics
  279.  */
  280. rt_stats(off)
  281.     off_t off;
  282. {
  283.     struct rtstat rtstat;
  284.  
  285.     if (off == 0) {
  286.         printf("rtstat: symbol not in namelist\n");
  287.         return;
  288.     }
  289.     kread(off, (char *)&rtstat, sizeof (rtstat));
  290.     printf("routing:\n");
  291.     printf("\t%d bad routing redirect%s\n",
  292.         rtstat.rts_badredirect, plural(rtstat.rts_badredirect));
  293.     printf("\t%d dynamically created route%s\n",
  294.         rtstat.rts_dynamic, plural(rtstat.rts_dynamic));
  295.     printf("\t%d new gateway%s due to redirects\n",
  296.         rtstat.rts_newgateway, plural(rtstat.rts_newgateway));
  297.     printf("\t%d destination%s found unreachable\n",
  298.         rtstat.rts_unreach, plural(rtstat.rts_unreach));
  299.     printf("\t%d use%s of a wildcard route\n",
  300.         rtstat.rts_wildcard, plural(rtstat.rts_wildcard));
  301. }
  302.  
  303. #ifdef    ENABLE_XNS
  304.  
  305. short ns_nullh[] = {0,0,0};
  306. short ns_bh[] = {-1,-1,-1};
  307.  
  308. char *
  309. ns_print(sns)
  310. struct sockaddr_ns *sns;
  311. {
  312.     struct ns_addr work;
  313.     union { union ns_net net_e; u_long long_e; } net;
  314.     u_short port;
  315.     static char mybuf[50], cport[10], chost[25];
  316.     char *host = "";
  317.     register char *p; register u_char *q; u_char *q_lim;
  318.  
  319.     work = sns->sns_addr;
  320.     port = ntohs(work.x_port);
  321.     work.x_port = 0;
  322.     net.net_e  = work.x_net;
  323.     if (ns_nullhost(work) && net.long_e == 0) {
  324.         if (port ) {
  325.             sprintf(mybuf, "*.%xH", port);
  326.             upHex(mybuf);
  327.         } else
  328.             sprintf(mybuf, "*.*");
  329.         return (mybuf);
  330.     }
  331.  
  332.     if (bcmp(ns_bh, work.x_host.c_host, 6) == 0) { 
  333.         host = "any";
  334.     } else if (bcmp(ns_nullh, work.x_host.c_host, 6) == 0) {
  335.         host = "*";
  336.     } else {
  337.         q = work.x_host.c_host;
  338.         sprintf(chost, "%02x%02x%02x%02x%02x%02xH",
  339.             q[0], q[1], q[2], q[3], q[4], q[5]);
  340.         for (p = chost; *p == '0' && p < chost + 12; p++);
  341.         host = p;
  342.     }
  343.     if (port)
  344.         sprintf(cport, ".%xH", htons(port));
  345.     else
  346.         *cport = 0;
  347.  
  348.     sprintf(mybuf,"%xH.%s%s", ntohl(net.long_e), host, cport);
  349.     upHex(mybuf);
  350.     return(mybuf);
  351. }
  352.  
  353. char *
  354. ns_phost(sns)
  355. struct sockaddr_ns *sns;
  356. {
  357.     struct sockaddr_ns work;
  358.     static union ns_net ns_zeronet;
  359.     char *p;
  360.     
  361.     work = *sns;
  362.     work.sns_addr.x_port = 0;
  363.     work.sns_addr.x_net = ns_zeronet;
  364.  
  365.     p = ns_print(&work);
  366.     if (strncmp("0H.", p, 3) == 0)
  367.         p += 3;
  368.     return(p);
  369. }
  370. upHex(p0)
  371. char *p0;
  372. {
  373.     register char *p = p0;
  374.     for (; *p; p++) switch (*p) {
  375.  
  376.     case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
  377.         *p += ('A' - 'a');
  378.     }
  379. }
  380. #endif    ENABLE_XNS
  381.  
  382.